﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Globalization;
using produccion.modelo;
using produccion.AccesoDatos;
using produccion.clases;
using System.Windows.Input;
using System.Collections.Specialized;

namespace produccion.vistamodelo
{
    class VMMantenimientodeSoluciones : ViewModelBase
    {
        #region Campos

            private List<CLSTABSOL> _lissolucion = new List<CLSTABSOL>();
            private ProcesoProduccionRepositorio _repositorio = new ProcesoProduccionRepositorio();

        #endregion

        #region Constructor

            public VMMantenimientodeSoluciones()
            {
                try
                {
                    consultarSoluciones();
                    lissoluciones.CollectionChanged += OnCollectionChanged;

                    if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                    {
                        MDOgeneral.conectar();
                    }
                    strTituloVentana = "Mantenimiento de soluciones - Usuario: " + MDOgeneral.usuario + " - [FRMMantenimientodeSoluciones]";
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

        #endregion

        #region Interfaces publicas

            private string _strTituloVentana;
            public string strTituloVentana
            {
                get { return _strTituloVentana; }
                set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
            }

            public List<CLSTABSOL> lissolucion
            {
                get { return _lissolucion; }
                set { _lissolucion = value; base.OnPropertyChanged("lissolucion"); }
            }

            private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
            public MDOgeneral.mensaje msn
            {
                get { return _msn; }
                set { _msn = value; base.OnPropertyChanged("msn"); }
            }

            private ObservableCollection<VMSoluciones> _lissoluciones = new ObservableCollection<VMSoluciones>();
            public ObservableCollection<VMSoluciones> lissoluciones
            {
                get { return _lissoluciones; }
                set { _lissoluciones = value; base.OnPropertyChanged("lissoluciones"); }
            }

            private VMSoluciones _selsolucion;
            public VMSoluciones selsolucion
            {
                get { return _selsolucion; }
                set { _selsolucion = value; base.OnPropertyChanged("selsolucion"); }
            }

            private Boolean _logValido;
            public Boolean logValido
            {
                get { return _logValido; }
                set { _logValido = value; base.OnPropertyChanged("logValido"); }
            }
            
        #endregion

        #region Comandos

            RelayCommand _cmdSalir;
            public ICommand cmdSalir
            { 
                get
                {
                    if (_cmdSalir==null)
                    {
                        _cmdSalir= new RelayCommand(Salir);
                    }
                    return _cmdSalir;
                }
            }

            RelayCommand _cmdEliminar;
            public ICommand cmdEliminar
            {
                get
                {
                    if (_cmdEliminar==null)
                    {
                        _cmdEliminar=new RelayCommand(r => eliminarSolucion());
                    }
                    return _cmdEliminar;
                }
            }

            RelayCommand _cmdGrabar;
            public ICommand cmdGrabar
            {
                get
                {
                    if (_cmdGrabar==null)
                    {
                        _cmdGrabar=new RelayCommand(r => grabarSolucion());
                    }
                    return _cmdGrabar;
                }
            }

        #endregion

        #region Metodos

            public void consultarSoluciones()
            {
                try
                {
                    lissolucion = _repositorio.consultarSoluciones();
                    List<VMSoluciones> all = (from sol in lissolucion select new VMSoluciones(sol)).ToList();
                    foreach (VMSoluciones sol in all)
                    {
                        sol.validarSolucion += validaSolucion;
                        sol.PropertyChanged += OnPropertyChanged;
                    }

                    lissoluciones = new ObservableCollection<VMSoluciones>(all);
                    lissoluciones.CollectionChanged += OnCollectionChanged;
                }
                catch(Exception ex) {MessageBox.Show(ex.Message);}
            }

            void OnPropertyChanged(object sender, PropertyChangedEventArgs e)    
            {
                logValido = ((from sol in lissoluciones where sol.IsValid.Equals(false) select sol.IsValid).ToList().Count())>0 ? true : false;
            }

            void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
            {
                try
                {
                    if (e.NewItems != null && e.NewItems.Count>0)
                    {
                        foreach (VMSoluciones sol in e.NewItems)
                        {
                            sol.validarSolucion += validaSolucion;
                            sol.PropertyChanged += OnPropertyChanged;
                        }
                    }
                }
                catch(Exception ex) { MessageBox.Show(ex.Message);}
            }

            public string validaSolucion(string strCodigosolucion)
            {
                try
                {
                    int i = (from sol in lissoluciones where sol.codsol_sol.Trim().Equals(strCodigosolucion.Trim()) select sol).ToList().Count();
                    if (i>1)
                    {
                        return "Código de solución ya existe.";
                    }
                }
                catch(Exception ex) {MessageBox.Show(ex.Message);}
                return null;
            }

            private void grabarSolucion()
            {
                try
                {
                    List<CLSTABSOL> lstAgregar = (from sol in lissoluciones where sol.agregar.Equals(true) select sol.getSoluciones()).ToList();
                    List<CLSTABSOL> lstActualizar = (from sol in lissoluciones where sol.actualizar.Equals(true) select sol.getSoluciones()).ToList();
                    List<CLSTABSOL> lstEliminar = (from sol in lissoluciones where sol.eliminar.Equals(true) select sol.getSoluciones()).ToList();

                    if (_repositorio.guardarSoluciones(lstActualizar, lstEliminar, lstAgregar))
                    {
                        msn.texto = "La información de soluciones fue guardada exitosamente.";
                        msn.tipo = true;
                        consultarSoluciones();
                    }
                    else
                    {
                        msn.texto = "La información de soluciones no se pudo grabar.";
                        msn.tipo = false;
                    }
                }
                catch(Exception ex) {MessageBox.Show(ex.Message);}
            }

            private void eliminarSolucion()
            {
                try
                {
                    if (selsolucion.agregar)
                        lissoluciones.Remove(selsolucion);
                    else
                        selsolucion.eliminar = !selsolucion.eliminar;
                }
                catch(Exception ex) { MessageBox.Show(ex.Message);}
            }

            public void Salir(Object frmformulario)
            {
                ((Window)frmformulario).Close();
            }


        #endregion

        #region Vistas-Modelo

            public class VMSoluciones : ViewModelBase, IDataErrorInfo
            {

                #region Campos

                    private CLSTABSOL _soluciones = new CLSTABSOL();
                    public delegate string validarCodigoSolucion(string codsol_sol);

                #endregion

                #region Constructor

                    public VMSoluciones(CLSTABSOL soluciones)
                    {
                        _soluciones = soluciones;
                    }

                    public VMSoluciones()
                    {
                        agregar = true;
                        base.OnPropertyChanged("codsol_sol");
                    }

                #endregion

                #region Metodos

                    public CLSTABSOL getSoluciones()
                    {
                        return _soluciones;
                    }

                #endregion

                #region Interfaces publicas

                    public validarCodigoSolucion validarSolucion;

                    public string codsol_sol
                    {
                        get { return _soluciones.CODSOL_SOL; }
                        set 
                        {
                            if (agregar == true)
                            {
                                _soluciones.CODSOL_SOL = value;
                                base.OnPropertyChanged("codsol_sol");
                            }
                        }
                    }

                    public string nombre_sol
                    {
                        get { return _soluciones.NOMBRE_SOL; }
                        set 
                        {
                            if (_soluciones.NOMBRE_SOL != value)
                                actualizar = true;
                            _soluciones.NOMBRE_SOL = value;
                            base.OnPropertyChanged("nombre_sol");
                        }
                    }


                    private bool _actualizar = false;
                    public bool actualizar
                    {
                        get { return _actualizar; }
                        set { _actualizar = value; base.OnPropertyChanged("actualizar"); }
                    }

                    private bool _eliminar = false;
                    public bool eliminar
                    {
                        get { return _eliminar; }
                        set { _eliminar = value; base.OnPropertyChanged("eliminar"); }
                    }

                    private bool _agregar = false;
                    public bool agregar
                    {
                        get { return _agregar; }
                        set { _agregar = value; base.OnPropertyChanged("agregar");
                        }
                    }

                #endregion

                #region IDataErrorInfo Members

                    string IDataErrorInfo.Error { get { return null; } }

                    string IDataErrorInfo.this[string propertyName]
                    {
                        get { return this.GetValidationError(propertyName); }
                    }

                #endregion

                #region Validation

                    /// <summary>
                    /// Returns true if this object has no validation errors.
                    /// </summary>
                    /// 

                    public bool IsValid
                    {
                        get
                        {
                            foreach (string property in ValidatedProperties) 
                                if (GetValidationError(property) != null)
                                    return false;
                       
                            return true;
                        }
                    }

                    static readonly string[] ValidatedProperties = 
                    { 
                        "codsol_sol",
                        "nombre_sol"
                    };

                    string GetValidationError(string propertyName)
                    {
                        if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                            return null;

                        string error = null;

                        switch (propertyName)
                        {
                            case "codsol_sol":
                                error = this.Validatecodigo();
                                break;
                            case "nombre_sol":
                                error = this.ValidateNombre();
                                break;
                            default:
                                Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                                break;
                        }
                        return error;
                    }

                    string Validatecodigo()
                    {
                        try
                        {
                            if (codsol_sol == null) { return "Debe ingresar el código de la solución."; }
                            if (codsol_sol != null)
                            {
                                if (codsol_sol.Length > 2) { return "El código de la solución no puede tener mas de 2 caracteres"; }
                                string error = null;
                                error = validarSolucion(codsol_sol);
                                if (!String.IsNullOrEmpty(error))
                                {
                                    return error;
                                }
                            }
                            return null;
                        }
                        catch (Exception ex) { MessageBox.Show(ex.Message); }
                        return null;
                    }

                    string ValidateNombre()
                    {
                        try
                        {
                            if (nombre_sol == null) { return "Debe ingresar el nombre de la solución"; }
                            if (nombre_sol != null)
                            {
                                if (nombre_sol.Length > 50) { return "El nombre de la solución no puede tener mas de 50 caracteres"; }
                            }

                            return null;
                        }
                        catch (Exception ex) { MessageBox.Show(ex.Message); }
                        return null;
                    }

                #endregion

            }

        #endregion
    }
}
